package com.xzmzhp.service.people.impl;

import cn.hutool.core.collection.CollUtil;
import com.github.pagehelper.PageInfo;
import com.xzmzhp.constant.ReturnConstant;
import com.xzmzhp.dao.power.CompetenceMapper;
import com.xzmzhp.dao.people.PersonnelMapper;
import com.xzmzhp.dao.people.PositionMapper;
import com.xzmzhp.pojo.power.Competence;
import com.xzmzhp.pojo.people.Personnel;
import com.xzmzhp.pojo.people.Position;
import com.xzmzhp.service.people.PersonnelService;
import com.xzmzhp.utils.CompetenceUtils;
import com.xzmzhp.dao.excel.ExcelMapper;
import com.xzmzhp.utils.return_tool.ReturnData;
import com.xzmzhp.utils.StringUtils;
import com.xzmzhp.vo.personnel.PersonnelVo;
import org.apache.ibatis.annotations.Param;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author 王源(xm)
 * @Date: 2020/11/19 21:16
 * @Description: 人员信息逻辑接口实现类
 */
@Service
public class PersonnelServiceImpl implements PersonnelService, ExcelMapper {

    @Autowired
    private PersonnelMapper personnelMapper;
    @Autowired
    private CompetenceMapper competenceMapper;
    @Autowired
    private PositionMapper positionMapper;

    @Autowired
    private BCryptPasswordEncoder encoder;


    /**
     * 查询所有人员信息
     *
     * @return ReturnData对象
     */
    @Override
    public ReturnData findAll() {
        List<PersonnelVo> list = personnelMapper.findAll();
        if (CollUtil.isNotEmpty(list)) {
            PageInfo<PersonnelVo> pageInfo = new PageInfo<>(list);
            return ReturnData.ok(list, pageInfo.getTotal());
        } else {
            return ReturnData.error(ReturnConstant.FAIL, "没有找到人员信息");
        }
    }

    /**
     * 根据人员id查询人员信息
     *
     * @param personnelId 人员id
     * @return ReturnData对象
     */
    @Override
    public ReturnData findByPersonnelId(int personnelId) {
        PersonnelVo personnelVo = personnelMapper.findByPersonnelId(personnelId);
        if (personnelVo != null) {
            return ReturnData.ok(personnelVo);
        } else {
            return ReturnData.error(ReturnConstant.FAIL, "没有找到人员信息");
        }
    }

    /**
     * 根据人员学号模糊查询人员信息
     *
     * @param studentId 学号
     * @return ReturnData对象
     */
    @Override
    public ReturnData findByStudentId(String studentId) {
        PersonnelVo personnelVo = personnelMapper.findByStudentId(studentId);
        if (personnelVo != null) {
            return ReturnData.ok(personnelVo);
        } else {
            return ReturnData.error(ReturnConstant.FAIL, "没有找到人员信息");
        }
    }

    /**
     * 根据人员姓名、权限名称、部门名称、年级其中的一个或多个查询人员数据
     *
     * @param personnelName  人员姓名
     * @param competenceName 权限名称
     * @param positionName   部门名称
     * @param personnelGrade 年级
     * @return ReturnData对象
     */
    @Override
    public ReturnData findPersonnel(String personnelName, String competenceName, String positionName, int personnelGrade) {
        List<PersonnelVo> list = personnelMapper.findPersonnel(personnelName, competenceName, positionName, personnelGrade);
        if (CollUtil.isNotEmpty(list)) {
            PageInfo<PersonnelVo> pageInfo = new PageInfo<>(list);
            return ReturnData.ok(list, pageInfo.getTotal());
        } else {
            return ReturnData.error(ReturnConstant.FAIL, "没有找到人员信息");
        }
    }

    /**
     * 根据权限id、部门id、年级其中的一个或多个查询人员数据
     *
     * @param competenceId   权限id
     * @param positionId     部门id
     * @param personnelGrade 年级
     * @return ReturnData对象
     */
    @Override
    public ReturnData checkPersonnel(int competenceId, int positionId, int personnelGrade, int personnelId) {
        List<Personnel> list = personnelMapper.checkPersonnel(competenceId, positionId, personnelGrade, personnelId);
        if (CollUtil.isNotEmpty(list)) {
            PageInfo<Personnel> pageInfo = new PageInfo<>(list);
            return ReturnData.ok(list, pageInfo.getTotal());
        } else {
            return ReturnData.error(ReturnConstant.FAIL, "没有找到人员信息");
        }
    }

    /**
     * 根据id查询活动名称
     *
     * @param personnelId 人员id
     * @return ReturnData
     */
    @Override
    public ReturnData findActivityNames(int personnelId) {
        List<String> strings = personnelMapper.findActivityNames(personnelId);
        if (StringUtils.isNotEmpty(strings)) {
            return ReturnData.ok(strings);
        } else {
            return ReturnData.error(ReturnConstant.FAIL, "没有找到活动名称");
        }
    }

    /**
     * 根据人员id查询人员信息
     *
     * @param personnelId 人员id数组
     * @return PersonnelVo
     */
    @Override
    public ReturnData findByPersonnelId(Integer[] personnelId) {
        List<PersonnelVo> list = personnelMapper.findByPersonnelIds(personnelId);
        if (StringUtils.isNotEmpty(list)) {
            PageInfo<PersonnelVo> pageInfo = new PageInfo<>(list);
            return ReturnData.ok(pageInfo);
        } else {
            return ReturnData.error(ReturnConstant.FAIL, "没有找到活动名称");
        }
    }

    /**
     * 添加人员信息
     *
     * @param personnel 人员信息实体类
     * @return ReturnData对象
     */
    @Override
    public ReturnData addPersonnel(Personnel personnel) {
        //判断学号是否存在
        if (personnelMapper.findByStudentId(personnel.getStudentId()) != null) {
            return ReturnData.error(ReturnConstant.FAIL, "学号已存在");
        }
        //判断职位 若为社长且数据库中不存在本年级社长 则添加 若为副社则超过两位 部长不超过两位
        CompetenceUtils competenceUtils = new CompetenceUtils();
        ReturnData returnData = competenceUtils.promotion(personnel, personnelMapper);
        if (returnData != null) {
            return returnData;
        }
        //密码加密
        personnel.setPersonnelPassword(encoder.encode(personnel.getStudentId()));
        //添加人员信息
        Integer i = personnelMapper.addPersonnel(personnel);
        if (i > 0) {
            return ReturnData.ok();
        } else {
            return ReturnData.error(ReturnConstant.FAIL, "人员信息添加失败");
        }
    }

    /**
     * 数据保存类
     *
     * @param list 数据集合
     * @return 成功 1 失败 0
     */
    @Override
    public ReturnData uploadData(List list) {
        //转换数据类型
        List<PersonnelVo> list1 = list;
        ReturnData returnData = null;
        //遍历数据
        for (PersonnelVo personnelVo : list1) {
            //获取权限名称
            String competenceName = personnelVo.getCompetenceName();
            //获取权限实体类
            Competence competence = competenceMapper.findByName(competenceName);
            //获取部门名称
            String positionName = personnelVo.getPositionName();
            //获取部门实体类
            Position position = positionMapper.findByName(positionName);

            //获取年级
            String grade = personnelVo.getStudentId().substring(0, 2);
            Integer personnelGrade = Integer.parseInt(grade);

            //定义人员实体类
            Personnel personnel = Personnel.builder()
                    .studentId(personnelVo.getStudentId())
                    .personnelName(personnelVo.getPersonnelName())
                    .competenceId(competence.getCompetenceId())
                    .personnelPhone(personnelVo.getPersonnelPhone())
                    .personnelPassword(personnelVo.getStudentId())
                    .personnelAcademy(personnelVo.getPersonnelAcademy())
                    .personnelClasses(personnelVo.getPersonnelClasses())
                    .personnelGrade(personnelGrade)
                    .positionId(position.getPositionId())
                    .build();
            //存入list
            returnData = this.addPersonnel(personnel);
        }
        return returnData;
    }

    /**
     * 修改人员信息
     *
     * @param personnel 人员信息实体类
     * @return ReturnData对象
     */
    @Override
    public ReturnData updatePersonnel(Personnel personnel) {
        //判断职位 若为社长且数据库中不存在本年级社长 则添加 若为副社则超过两位 部长不超过两位
        CompetenceUtils competenceUtils = new CompetenceUtils();
        ReturnData returnData = competenceUtils.promotion(personnel, personnelMapper);
        if (returnData != null) {
            return returnData;
        }
        //修改人员信息
        personnel.setPersonnelPassword(encoder.encode(personnel.getPersonnelPassword()));
        Integer i = personnelMapper.updatePersonnel(personnel);
        if (i > 0) {
            return ReturnData.ok();
        } else {
            return ReturnData.error(ReturnConstant.FAIL, "人员信息修改失败");
        }
    }

    /**
     * 查询部门人数
     * @param positionId 部门id
     * @param grade 年级
     * @return 部门总人数
     */
    @Override
    public Integer findPositionPeoples(Integer positionId, Integer grade) {
        if (StringUtils.isNull(positionId)){
            return ReturnConstant.FAIL;
        }
        return personnelMapper.findPositionPeoples(positionId,grade);
    }

    /**
     * 批量修改人员部门
     * @param primaryPositionId 原部门id
     * @param targetPositionId  目标部门id
     * @param grade 年级
     * @return 修改信息
     */
    @Override
    public Integer exitBatchPosition(@Param("primaryPositionId") Integer primaryPositionId, @Param("targetPositionId") Integer targetPositionId, Integer grade){
        //修改部门信息
        Integer i = personnelMapper.exitBatchPosition(primaryPositionId,targetPositionId,grade);
        return StringUtils.isNotNull(i)?i:0;
    }


    /**
     * 删除人员信息
     *
     * @param personnelId 人员id
     * @return ReturnData对象
     */
    @Override
    public ReturnData deletePersonnel(int personnelId) {
        Integer i = personnelMapper.deletePersonnel(personnelId);
        if (i > 0) {
            return ReturnData.ok();
        } else {
            return ReturnData.error(ReturnConstant.FAIL, "人员信息删除失败");
        }
    }
}
